const jwt = require('jsonwebtoken');
const User = require('../models/User');
const config = require('../config/auth');
const { successResponse, errorResponse } = require('../utils/response');
const logger = require('../utils/logger');
const svgCaptcha = require('svg-captcha');

// 存储验证码的会话数据
const captchaStore = new Map();

// 用户注册
exports.register = async (req, res) => {
  try {
    const { username, password, name, email, role } = req.body;

    // 检查用户名是否已存在
    const existingUser = await User.findOne({ $or: [{ username }, { email }] });
    if (existingUser) {
      if (existingUser.username === username) {
        return errorResponse(res, '用户名已存在', 400);
      }
      return errorResponse(res, '邮箱已存在', 400);
    }

    // 创建新用户
    const user = new User({
      username,
      password,
      name,
      email,
      role: role || 'user'
    });

    await user.save();

    // 创建并返回 JWT
    const token = jwt.sign({ id: user.id }, config.jwtSecret, {
      expiresIn: config.jwtExpiresIn
    });

    // 返回用户信息(排除密码)
    const userResponse = {
      id: user.id,
      username: user.username,
      name: user.name,
      email: user.email,
      role: user.role
    };

    return successResponse(res, { user: userResponse, token }, '注册成功', 201);
  } catch (error) {
    logger.error(`注册失败: ${error.message}`);
    return errorResponse(res, '注册失败', 500);
  }
};

// 生成验证码
exports.generateCaptcha = (req, res) => {
  // 创建验证码
  const captcha = svgCaptcha.create({
    size: 4, // 验证码长度
    ignoreChars: '0o1il', // 排除容易混淆的字符
    noise: 2, // 干扰线条的数量
    color: true, // 验证码的颜色
    background: '#f0f2f5' // 背景颜色
  });
  
  // 生成唯一标识符
  const captchaId = Date.now() + Math.random().toString(36).substring(2, 10);
  
  // 存储验证码(5分钟过期)
  captchaStore.set(captchaId, {
    text: captcha.text.toLowerCase(),
    expires: Date.now() + 5 * 60 * 1000
  });
  
  // 设置cookie，包含验证码ID
  res.cookie('captchaId', captchaId, { 
    httpOnly: true, 
    maxAge: 5 * 60 * 1000 
  });
  
  // 返回SVG图片
  res.type('svg');
  res.status(200).send(captcha.data);
};

// 登录处理
exports.login = async (req, res) => {
  try {
    const { username, password, captcha } = req.body;
    const captchaId = req.cookies.captchaId;
    
    // 验证码校验（如果验证码功能启用）
    if (captcha && captchaId && captchaStore.has(captchaId)) {
      const storedCaptcha = captchaStore.get(captchaId);
      
      // 检查验证码是否过期
      if (Date.now() > storedCaptcha.expires) {
        captchaStore.delete(captchaId);
        return res.status(400).json({
          success: false,
          message: '验证码已过期，请重新获取'
        });
      }
      
      // 验证码不正确
      if (storedCaptcha.text !== captcha.toLowerCase()) {
        return res.status(400).json({
          success: false,
          message: '验证码不正确'
        });
      }
      
      // 验证完成后删除验证码
      captchaStore.delete(captchaId);
    } else if (process.env.NODE_ENV === 'production') {
      // 在生产环境中要求验证码
      return res.status(400).json({
        success: false,
        message: '请输入验证码'
      });
    }
    
    // 查找用户
    const user = await User.findOne({ username });
    if (!user) {
      return res.status(401).json({
        success: false,
        message: '用户名或密码不正确'
      });
    }
    
    // 验证密码
    const isMatch = await user.comparePassword(password);
    if (!isMatch) {
      return res.status(401).json({
        success: false,
        message: '用户名或密码不正确'
      });
    }
    
    // 生成token
    const token = jwt.sign(
      { id: user._id, username: user.username, role: user.role },
      config.jwtSecret,
      { expiresIn: '24h' }
    );
    
    // 返回用户信息和token
    return res.json({
      success: true,
      message: '登录成功',
      data: {
        token,
        user: {
          id: user._id,
          username: user.username,
          name: user.name,
          email: user.email,
          role: user.role,
          avatar: user.avatar
        }
      }
    });
  } catch (error) {
    console.error('登录错误:', error);
    return res.status(500).json({
      success: false,
      message: '服务器错误，请稍后重试'
    });
  }
};

// 获取当前用户信息
exports.getCurrentUser = async (req, res) => {
  try {
    return successResponse(res, req.user, '获取用户信息成功');
  } catch (error) {
    logger.error(`获取用户信息失败: ${error.message}`);
    return errorResponse(res, '获取用户信息失败', 500);
  }
};

// 修改密码
exports.changePassword = async (req, res) => {
  try {
    const { currentPassword, newPassword } = req.body;
    const user = await User.findById(req.user.id);

    // 验证当前密码
    const isMatch = await user.comparePassword(currentPassword);
    if (!isMatch) {
      return errorResponse(res, '当前密码错误', 400);
    }

    // 更新密码
    user.password = newPassword;
    await user.save();

    return successResponse(res, null, '密码修改成功');
  } catch (error) {
    logger.error(`修改密码失败: ${error.message}`);
    return errorResponse(res, '修改密码失败', 500);
  }
}; 